{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Taylor integration example: $\\dot x=x^2$\n",
    "\n",
    "Here, we will integrate the initial-value problem (IVP) defined by\n",
    "\n",
    "$$\n",
    "\\begin{align}\n",
    "\\dot x &= x^2 \\\\\n",
    "x(0)&=x_0\n",
    "\\end{align}\n",
    "$$\n",
    "\n",
    "Given a real number $A>0$, the restriction of the function $f(x)=x^2$ over the interval $I_A=(-A,A)$ satisfies the Lipschitz condition $|f(x_1)-f(x_2)|=|x_1^2-x_2^2|=|x_1+x_2|\\cdot|x_1-x_2| \\leq 2A|x_1-x_2|$ for every $x_1,x_2 \\in I_A$. Therefore, the Picard-Lindelöf theorem for ordinary differential equations guarantees there exists a $\\delta>0$ such that a solution for this IVP exists and is unique for $t \\in [0,\\delta]$, for any $x_0 \\in I_A$. Note that in this case, it is necessary to restrict the function to a bounded interval in order to obtain a Lipschitz condition, which in turn is necessary to fulfill the conditions of the Picard-Lindelöf theorem.\n",
    "\n",
    "Now, for any initial condition $x_0$, $t_0\\in\\mathbb{R}$ the analytical solution for this problem is:\n",
    "\n",
    "$$\n",
    "x(t)=\\frac{x_0}{1-x_0\\cdot (t-t_0)}\n",
    "$$\n",
    "\n",
    "In particular, the analytical solution exhibits a divergence at $t^*=t_0+1/x_0$; i.e., the solution is guaranteed to exist only for $t \\in [t_0,t_0+1/x_0)$ if $x_0>0$. Otherwise, if $x_0<0$, then the analytical solution \"moves away\" from the singularity, since in this case we have $t^*=t_0+1/x_0<t_0$ (i.e., if $x_0<0$, the singularity is in the \"past\"). How does a numerical integrator behave near this divergence, when $x_0>0$?\n",
    "\n",
    "We will try three methods to integrate this problem:\n",
    "\n",
    "+ Adaptive time-step, 4th-order, Runge-Kutta (`ODE.jl`)\n",
    "+ Taylor method (`TaylorIntegration.jl`)\n",
    "+ Adaptive time-step, Runge-Kutta-Fehlberg 7/8 method (`ODE.jl`)\n",
    "\n",
    "As initial conditions to integrate this IVP, we choose $x_0=3$, $t_0=0$, since then the singularity will be at $t^*=1/3$, and this number is not exactly representable in a binary floating-point format. Thus, any constant time-step numerical integrator should break down when integrating up to $t_\\mathrm{max}=1/3$, or beyond.\n",
    "\n",
    "We start off by including the relevant packages:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "using TaylorIntegration, ODE, Plots, LaTeXStrings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ODE:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "diffeq (generic function with 1 method)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diffeq(t, x) = x.^2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Adaptive time-step, 4th order, Runge Kutta method\n",
    "\n",
    "We select $x_0=3$, $t_0=0$. Then, the singularity is at $t=1/3$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Warning: dt < minstep.  Stopping.\n",
      "  1.397936 seconds (1.51 M allocations: 64.582 MB, 1.80% gc time)\n",
      "Warning: dt < minstep.  Stopping.\n",
      "  0.000970 seconds (11.54 k allocations: 465.828 KB)\n"
     ]
    }
   ],
   "source": [
    "@time tRK, xRK = ode45(diffeq, 3.0, [0.0, 0.34]); #warmup lap\n",
    "@time tRK, xRK = ode45(diffeq, 3.0, [0.0, 0.34]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot $x$ vs $t$ (log-log):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"\" />"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "sys:1: MatplotlibDeprecationWarning: The set_axis_bgcolor function was deprecated in version 2.0. Use set_facecolor instead.\n"
     ]
    }
   ],
   "source": [
    "pyplot()\n",
    "plot(log10(tRK[2:end]), log10(xRK[2:end]))\n",
    "title!(\"x vs t (log-log)\")\n",
    "xlabel!(L\"\\log_{10}(t)\")\n",
    "ylabel!(L\"\\log_{10}(x(t))\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is the final state of the system?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.33333423758781194,7.125446356124256e17)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tRK[end], xRK[end]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Does the integrator get past the singularity?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "true"
      ],
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tRK[end]>1/3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The answer is yes! So the last value of the solution is meaningless:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "7.125446356124256e17"
      ],
      "text/plain": [
       "7.125446356124256e17"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xRK[end] #this value is meaningless"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How many steps did the RK integrator perform?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "166"
      ],
      "text/plain": [
       "166"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "length(xRK)-1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How does the numerical solution compare to the analytical solution? The analytical solution is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "exactsol (generic function with 1 method)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exactsol(t, x0) = x0./(1.0-x0.*t) #analytical solution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The relative difference between the numerical and analytical solution, $\\delta x$, is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "δxRK = (xRK-exactsol(tRK, 3.0))./exactsol(tRK, 3.0) #numerical error, relative to analytical solution\n",
    ";"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The $\\delta x$ vs $t$ plot (semilog):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"\" />"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(tRK[2:end], log10(abs(δxRK[2:end])))\n",
    "title!(\"Relative error (semi-log)\")\n",
    "xlabel!(L\"\\log_{10}(t)\")\n",
    "ylabel!(L\"\\log_{10}(\\delta x(t))\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This plot means that the error of the numerical solution grows systematically; and at the end of the integration, the error in the numerical solution is"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "5.433622064235371e17"
      ],
      "text/plain": [
       "5.433622064235371e17"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(xRK[end-1]-exactsol(tRK[end-1], 3.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Taylor method\n",
    "\n",
    "Again, we select $x_0=3$, $t_0=0$. The order of the Taylor integration is $28$, and we set the absolute tolerance equal to $10^{-20}$; this value is used during each time-step in order to compute an adaptive step size. We set the maximum number of integration steps equal to the number of steps that the previous integrator did."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\u001b[1m\u001b[31mWARNING: Maximum number of integration steps reached; exiting.\u001b[0m\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0.215803 seconds (160.86 k allocations: 8.295 MB)\n",
      "  0.001468 seconds (19.65 k allocations: 2.171 MB)\n"
     ]
    }
   ],
   "source": [
    "@time tT, xT = taylorinteg(diffeq, 3.0, 0.0, 0.34, 28, 1e-20, maxsteps=length(xRK)-1); #warmup lap\n",
    "@time tT, xT = taylorinteg(diffeq, 3.0, 0.0, 0.34, 28, 1e-20, maxsteps=length(xRK)-1);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.3333333329479479,2.5948055925168757e9)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tT[end], xT[end]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How many steps did the Taylor integrator perform?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "166"
      ],
      "text/plain": [
       "166"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "length(xT)-1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, we show the $x$ vs $t$ plot (log-log):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"\" />"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(log10(tT[2:end]), log10(xT[2:end]))\n",
    "title!(\"x vs t (log-log)\")\n",
    "xlabel!(L\"\\log_{10}(t)\")\n",
    "ylabel!(L\"\\log_{10}(x(t))\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Does the integrator get past the singularity?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "false"
      ],
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tT[end] > 1/3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The answer is no! Even if we increase the value of the `maxsteps` keyword in `taylorinteg`, it doesn't get past the singularity!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, the relative difference between the numerical and analytical solution, $\\delta x$, is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "δxT = (xT.-exactsol(tT, 3.0))./exactsol(tT, 3.0);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The $\\delta x$ vs $t$ plot (logscale):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"\" />"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(tT[6:end], log10(abs(δxT[6:end])))\n",
    "title!(\"Relative error (semi-log)\")\n",
    "xlabel!(L\"t\")\n",
    "ylabel!(L\"\\log_{10}(\\delta x(t))\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We observe that, while the execution time is ~10 times longer wrt 4th-order RK, the numerical solution obtained by the Taylor integrator stays within $10^{-12}$ of the analytical solution, for a same number of steps.\n",
    "\n",
    "Now, that happens if we use a higher order Runge Kutta method to integrate this problem?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 3. Runge-Kutta-Fehlberg 7/8 method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we use the Runge-Kutta-Fehlberg 7/8 method, included in `ODE.jl`, to integrate the same problem as before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Warning: dt < minstep.  Stopping.\n",
      "  0.379769 seconds (345.22 k allocations: 15.063 MB, 2.40% gc time)\n",
      "Warning: dt < minstep.  Stopping.\n",
      "  0.001199 seconds (12.76 k allocations: 494.219 KB)\n"
     ]
    }
   ],
   "source": [
    "@time t78, x78 = ode78(diffeq, 3.0, [0.0, 0.34]); #warmup lap\n",
    "@time t78, x78 = ode78(diffeq, 3.0, [0.0, 0.34]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot $x$ vs $t$ (log-log):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"\" />"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(log10(t78[2:end]), log10(x78[2:end]))\n",
    "title!(\"x vs t (log-log)\")\n",
    "xlabel!(L\"\\log_{10}(t)\")\n",
    "ylabel!(L\"\\log_{10}(x(t))\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is the final state of the system?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.3333336190078445,1.6711546943686948e18)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t78[end], x78[end]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Does the integrator get past the singularity?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "true"
      ],
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t78[end]>1/3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The answer is yes! So the last value of the solution is meaningless:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "1.6711546943686948e18"
      ],
      "text/plain": [
       "1.6711546943686948e18"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x78[end] #this value is meaningless"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How many steps did the RK integrator perform?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "91"
      ],
      "text/plain": [
       "91"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "length(x78)-1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The relative difference between the numerical and analytical solution, $\\delta x$, is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "δx78 = (x78-exactsol(t78, 3.0))./exactsol(t78, 3.0) #error relative to analytical solution\n",
    ";"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The $\\delta x$ vs $t$ plot (semilog):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"\" />"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(t78[2:end], log10(abs(δx78[2:end])))\n",
    "title!(\"Relative error (semi-log)\")\n",
    "xlabel!(L\"t\")\n",
    "ylabel!(L\"\\log_{10}(\\delta x(t))\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This time, the RKF 7/8 integrator is \"only\" twice as fast as the Taylor integrator, but the error continues to be greater than the error from the latter by several orders of magnitude."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Adaptive 4th-order RK, stringer tolerance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As a last example, we will integrate once again our problem using a 4th-order adaptive RK integrator, but imposing a stringer tolerance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Warning: dt < minstep.  Stopping.\n",
      "  0.127591 seconds (383.26 k allocations: 16.016 MB, 6.19% gc time)\n",
      "Warning: dt < minstep.  Stopping.\n",
      "  0.029600 seconds (335.10 k allocations: 13.837 MB, 31.90% gc time)\n"
     ]
    }
   ],
   "source": [
    "@time tRK_, xRK_ = ode45(diffeq, 3.0, [0.0, 0.34], abstol=1e-8, reltol=1e-8 ); #warmup lap\n",
    "@time tRK_, xRK_ = ode45(diffeq, 3.0, [0.0, 0.34], abstol=1e-8, reltol=1e-8 );\n",
    ";"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, the integrator takes 10 times longer to complete the integration than the Taylor method."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Does it get past the singularity?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "true"
      ],
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tRK_[end] > 1/3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yes! So, once again, the last value reported by the integrator is completely meaningless. But, has it attained a higher precision than the Taylor method? Well, let's calculate once again the numerical error relative to the analytical solution:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "δxRK_ = (xRK_-exactsol(tRK_, 3.0))./exactsol(tRK_, 3.0);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now, let's plot this relative error vs time:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"\" />"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(tRK_[2:end], log10(abs(δxRK_[2:end])))\n",
    "title!(\"Relative error (semi-log)\")\n",
    "xlabel!(L\"t\")\n",
    "ylabel!(L\"\\log_{10}(\\delta x(t))\")\n",
    "ylims!(-20,20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The numerical error has actually gotten worse! `TaylorIntegration.jl` is indeed a really competitive package to integrate ODEs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 0.5.1-pre",
   "language": "julia",
   "name": "julia-0.5"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "0.5.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}
